/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package pruebas;

import Dominio.Entidades.Celda;
import Dominio.Entidades.Coordenada;
import Dominio.Entidades.Jugada;
import Dominio.Entidades.Jugador;
import Dominio.Entidades.Partida;
import Dominio.Entidades.Pieza;
import Dominio.Entidades.TipoPieza;
import java.io.IOException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 *
 * @author 146122
 */
public class JuanPrueba {

    /**
     * @param args the command line arguments
     */
    public static void main(String[] args) throws IOException, ClassNotFoundException, Exception {

        //Ordenar las corrdenadas de la ubicacion de la pieza
        Coordenada[] lista = {new Coordenada(1, 1), new Coordenada(2, 2), new Coordenada(1, 2)};
        Pieza pieza = new Pieza(TipoPieza.LadrilloL, lista);
        pieza.ordenarUbicaciones();
        for (int i = 0; i < pieza.getUbicacion().length; i++) {

            System.out.println(pieza.getUbicacion()[i].toString());
        }


        //Comparar coordenadas
        Coordenada a3 = new Coordenada(0, 2);
        Coordenada b3 = new Coordenada(1, 2);
        Coordenada b4 = new Coordenada(1, 3);

        System.out.println("A3 con B3 " + a3.compareTo(b3));
        System.out.println("A3 con B4 " + a3.compareTo(b4));
        System.out.println("B3 con A3 " + b3.compareTo(a3));
        System.out.println("B3 con B4 " + b3.compareTo(b4));
        System.out.println("B4 con A3 " + b4.compareTo(a3));
        System.out.println("B4 con B3 " + b4.compareTo(b3));

        //p b2c3b3
        Coordenada[] lista22 = {new Coordenada(1, 1), new Coordenada(2, 2), new Coordenada(1, 2)};
        //p d2d3e3
        Coordenada[] lista23 = {new Coordenada(3, 1), new Coordenada(3, 2), new Coordenada(4, 2)};
        //p d1c1c2
        Coordenada[] lista24 = {new Coordenada(3, 0), new Coordenada(2, 0), new Coordenada(2, 1)};
        //p a3a4b4
        Coordenada[] lista25 = {new Coordenada(0, 2), new Coordenada(0, 3), new Coordenada(1, 3)};
        //p a1a2b1
        Coordenada[] lista30 = {new Coordenada(0, 0), new Coordenada(0, 1), new Coordenada(1, 0)};
        //p a1
        Coordenada[] lista31 = {new Coordenada(0, 0)};

        //p d2d3
        Coordenada[] lista26 = {new Coordenada(3, 1), new Coordenada(3, 2)};
        //p d1
        Coordenada[] lista27 = {new Coordenada(3, 0)};
        //p a3a4b4
        Coordenada[] lista28 = {new Coordenada(0, 2), new Coordenada(0, 3), new Coordenada(1, 3)};

        //p d1
        Coordenada[] lista29 = {new Coordenada(3, 0)};


        Partida pPartida = new Partida(new Jugador("a", "a", 10), new Jugador("b", "b", 10), new Celda[6][6], 10, 20);

        pPartida.getListaJugadas().add(new Jugada(1,new Jugador("a", "a", 12), new Pieza(TipoPieza.LadrilloL, lista22), lista22, 1, true));
        pPartida.getListaJugadas().add(new Jugada(2,new Jugador("b", "b", 12), new Pieza(TipoPieza.LadrilloL, lista23), lista23, 1, true));
        pPartida.getListaJugadas().add(new Jugada(3,new Jugador("a", "a", 12), new Pieza(TipoPieza.LadrilloL, lista24), lista24, 1, true));
        pPartida.getListaJugadas().add(new Jugada(4,new Jugador("b", "b", 12), new Pieza(TipoPieza.LadrilloL, lista25), lista25, 1, true));
        pPartida.getListaJugadas().add(new Jugada(5,new Jugador("a", "a", 12), new Pieza(TipoPieza.Rectangulo, lista26), lista26, 2, true));
        pPartida.getListaJugadas().add(new Jugada(6,new Jugador("b", "b", 12), new Pieza(TipoPieza.Cuadrado, lista27), lista27, 2, true));
        pPartida.getListaJugadas().add(new Jugada(7,new Jugador("a", "a", 12), new Pieza(TipoPieza.LadrilloL, lista28), lista28, 2, true));
        pPartida.getListaJugadas().add(new Jugada(8,new Jugador("b", "b", 12), new Pieza(TipoPieza.Ficha, lista29) {
            @Override
            public String getFicha() {
                return "N"; //To change body of generated methods, choose Tools | Templates.
            }
        }, lista29, 3, true));
        pPartida.getListaJugadas().add(new Jugada(9,new Jugador("a", "a", 12), new Pieza(TipoPieza.LadrilloL, lista30), lista30, 1, true));
        pPartida.getListaJugadas().add(new Jugada(10,new Jugador("b", "b", 12), new Pieza(TipoPieza.Ficha, lista29) {
            @Override
            public String getFicha() {
                return "N"; //To change body of generated methods, choose Tools | Templates.
            }
        }, lista29, 3, false));
        pPartida.getListaJugadas().add(new Jugada(11,new Jugador("a", "a", 12), new Pieza(TipoPieza.Ficha, lista31) {
            @Override
            public String getFicha() {
                return "B"; //To change body of generated methods, choose Tools | Templates.
            }
        }, lista31, 1, true));
        
        
        pPartida.cargarJugadasEnTablero();
        System.out.println(new DibujaTablero(pPartida.getTablero()));



        Pieza pieza0 = new Pieza(TipoPieza.LadrilloL, lista22);
        pieza0.movimientosValidos();
        Pieza pieza1 = new Pieza(TipoPieza.LadrilloL, lista23);
        pieza1.movimientosValidos();
        Pieza pieza2 = new Pieza(TipoPieza.LadrilloL, lista24);
        pieza2.movimientosValidos();
        Pieza pieza3 = new Pieza(TipoPieza.LadrilloL, lista25);
        pieza3.movimientosValidos();
        Pieza pieza4 = new Pieza(TipoPieza.Rectangulo, lista26);
        pieza4.movimientosValidos();
        Pieza pieza5 = new Pieza(TipoPieza.Cuadrado, lista27);
        pieza5.movimientosValidos();
        Pieza pieza6 = new Pieza(TipoPieza.LadrilloL, lista28);
        pieza6.movimientosValidos();


        //Falso
        Coordenada[] lista1 = new Coordenada[3];
        lista1[0] = new Coordenada(3, 1);
        lista1[1] = new Coordenada(3, 2);
        lista1[2] = new Coordenada(4, 2);

        Jugada jugada1 = new Jugada(new Jugador("a", "a", 12), null, "D1D2E4", true);

        //System.out.println("Es el ingreso es: " + pPartida.validarIngresoLadrillo(jugada1));

        //Verdadero
        Coordenada[] lista2 = new Coordenada[3];
        lista2[0] = new Coordenada(3, 3);
        lista2[1] = new Coordenada(3, 4);
        lista2[2] = new Coordenada(2, 4);

        Jugada jugada2 = new Jugada(new Jugador("b", "b", 12), null, "D3D4C4", true);

        //System.out.println("Es el ingreso es: " + pPartida.validarIngresoLadrillo(jugada2));

        //Falso
        Coordenada[] lista3 = new Coordenada[3];
        lista3[0] = new Coordenada(4, 2);
        lista3[1] = new Coordenada(4, 3);
        lista3[2] = new Coordenada(2, 4);

        Jugada jugada3 = new Jugada(new Jugador("a", "a", 12), null, "E2E3C4", true);

        //System.out.println("Es el ingreso es: " + pPartida.validarIngresoLadrillo(jugada3));

        //Falso
        Coordenada[] lista4 = new Coordenada[3];
        lista4[0] = new Coordenada(1, 2);
        lista4[1] = new Coordenada(2, 2);
        lista4[2] = new Coordenada(1, 3);

        Jugada jugada4 = new Jugada(new Jugador("b", "b", 12), null, "B2C2B3", true);

        //System.out.println("Es el ingreso es: " + pPartida.validarIngresoLadrillo(jugada4));

        //Falso
        Coordenada[] lista5 = new Coordenada[3];
        lista5[0] = new Coordenada(4, 5);
        lista5[1] = new Coordenada(5, 4);
        lista5[2] = new Coordenada(5, 5);

        Jugada jugada5 = new Jugada(new Jugador("a", "a", 12), null, "E5F4F5", true);

        //System.out.println("Es el ingreso es: " + pPartida.validarIngresoLadrillo(jugada5));

        //Verdadero
        Coordenada[] lista6 = new Coordenada[3];
        lista6[0] = new Coordenada(1, 4);
        lista6[1] = new Coordenada(0, 4);
        lista6[2] = new Coordenada(0, 5);

        Jugada jugada6 = new Jugada(new Jugador("b", "b", 12), null, "B4A4A5", true);

        //System.out.println("Es el ingreso es: " + pPartida.validarIngresoLadrillo(jugada6));




        //Esta expresion regular controla el formato de las coordenadas ingresado por el usuario
        Pattern p = Pattern.compile("(?:[A-H][1-8]).*?");
        Matcher m = p.matcher("A2C2J1222A11V9D1A0A3ABC");
        System.out.println("Aplicando el filtro: " + m.toString());
        System.out.println("Valida el texto: " + m.find());
        System.out.println("El texto invalido es: " + m.replaceAll(""));
        m = p.matcher("A2C2H1");
        System.out.println("El texto valido es: " + m.replaceAll(""));

        String movimiento = "R A2C2H1";
        System.out.println("Opcion: |" + movimiento.substring(0, 1) + "|");
        System.out.println("Espacio: |" + movimiento.substring(1, 2) + "|");
        System.out.println("Movimiento: |" + movimiento.substring(1, movimiento.length()
                - 2).trim() + "|");

        System.out.println("Modulo: " + 4 % 2);
        // TODO code application logic here
        String[][] matriz = {{"", "", "1C", "", "", "", "", ""},
            {"", "1L12", "1L1122", "", "", "", "", ""},
            {"", "", "1L12", "2C", "1C", "", "", ""},
            {"", "", "", "", "", "", "", ""},
            {"", "", "", "", "", "", "", ""},
            {"", "", "", "", "", "", "", ""},
            {"", "", "", "", "", "", "", ""},
            {"", "", "", "", "", "", "", ""}};
        //ssadfasd

        //String[][] matriz = new String[8][8];
        Celda[][] matriz1 = {{null, null, new Celda(false, false, 1, null, true), null, null, null, null, null},
            {null, new Celda(false, false, 1, null, true), new Celda(false, true, 1, null, true), null, null, null, new Celda(false, false, 1, "N", false), new Celda(false, false, 0, "N", false)},
            {new Celda(false, false, 1, null, true), new Celda(false, false, 1, "B", false), new Celda(true, false, 1, null, true), new Celda(false, false, 2, null, true), new Celda(false, false, 1, null, true), null, null, null},
            {null, new Celda(false, false, 1, null, true), new Celda(false, true, 1, null, true), null, null, null, new Celda(false, false, 1, null, true), null},
            {null, new Celda(true, false, 1, null, true), null, null, null, new Celda(false, false, 1, null, true), new Celda(true, true, 1, null, true), null},
            {null, null, null, null, new Celda(false, false, 1, null, true), new Celda(false, true, 1, null, true), null, null},
            {new Celda(false, false, 2, null, true), null, null, new Celda(false, false, 2, "R", false), new Celda(false, false, 2, "N", false), null, null, new Celda(false, false, 1, null, true)},
            {new Celda(true, false, 2, null, true), null, null, new Celda(false, false, 2, "J", false), null, null, new Celda(false, false, 1, null, true), new Celda(true, true, 1, null, true)}};

        Celda[][] matriz2 = {{null, null, new Celda(false, true, 2, "N", true), null},
            {null, null, new Celda(false, false, 1, null, true), new Celda(false, true, 2, "B", true)},
            {null, new Celda(false, false, 2, null, true), new Celda(false, true, 2, null, true), new Celda(false, false, 0, "N", false)},
            {null, null, new Celda(false, false, 1, null, true), null},};

        Celda[][] matriz3 = {{new Celda(false, false, 1, "B", false), null, null, new Celda(false, false, 1, "B", false)},
            {null, new Celda(false, false, 1, null, true), null, null},
            {new Celda(false, false, 1, null, true), new Celda(true, true, 1, null, true), null, null},
            {new Celda(false, false, 2, "B", true), new Celda(false, false, 1, null, true), new Celda(false, true, 1, null, true), new Celda(false, false, 2, "B", true)}};

        //System.out.print(new DibujaTablero(matriz1).toString());

        //System.out.print(new DibujaTablero(matriz2).toString());

        //System.out.print(new DibujaTablero(matriz3).toString());

        //Descomentar para probar con las funciones de esta clase.
        //dibujarTableroConCeldas(matriz2);
    }

    private static class DibujaTablero {

        //Atributos
        private Celda[][] matriz;
        private String saltoLinea = "\n";
        private String margen = "   ";
        private String bordeTOP = "o---";
        private String bordeTOPFIN = "o---o";
        private String bordeTOPUsado = "****";
        private String bordeTOPUsadoFIN = "*****";
        private String bordeTOPAnterior = "*---";
        private String bordeTOPAnteriorFIN = "*---o";
        private String bordeTOPLindero = "*   ";
        private String bordeTOPLinderoFIN = "*   *";
        private String bordeLEF = "|   ";
        private String bordeLEFFIN = "|   |";
        private String bordeLEFAnterior = "*   ";
        private String bordeLEFAnteriorFIN = "*   |";
        private String bordeLEFUsado = "*%s%s%s";
        private String bordeLEFUsadoFIN = "*%s%s%s*";
        private String bordeLEFLindero = " %s%s%s";
        private String bordeLEFLinderoFIN = " %s%s%s*";
        private String bordeLEFFicha = "|%s%s%s";
        private String bordeLEFFichaFIN = "|%s%s%s|";
        private String bordeLEFFichaAnterior = "*%s%s%s";
        private String bordeLEFFichaAnteriorFIN = "*%s%s%s|";

        //Contructor con parametros
        public DibujaTablero(Celda[][] pMatriz) {
            this.matriz = pMatriz;
        }

//        public void setMatriz(Celda[][] matriz) {
//            this.matriz = matriz;
//        }
        @Override
        public String toString() {
            return dibujarTableroConCeldas();
        }

        private String dibujarTableroConCeldas() {
            StringBuilder retorno = new StringBuilder();
            try {

                //System.out.println(cabezal);
                retorno.append(escribirNumeroColumna());
                //System.out.print(retorno);
                retorno.append(saltoLinea);
                //System.out.print(retorno);

                //Recorro la matriz por fila
                for (int posFila = 0; posFila < matriz.length; posFila++) {
                    Celda[] fila = matriz[posFila];

                    //Repito cada posicion cuatro veces para generar los renglones de una fila
                    for (int renglon = 0; renglon < 4; renglon++) {
                        //Escribo la letra de la fila cuando el renglon es el tecero
                        //y la columna es 0.
                        if (renglon == 2) {
                            retorno.append(escribirLetraFila(posFila));
                        } else {
                            retorno.append(margen);
                            //System.out.print(retorno);
                        }
                        //Recorro cada celda para ver si tengo que dibujarla con contenido
                        for (int posColumna = 0; posColumna < fila.length; posColumna++) {
                            Celda celda = fila[posColumna];
                            //linea = dibujarCeldaVacia(celda, r, linea, bordeTOPLimpio, bordeLeftLimpio);

                            if (renglon == 0) {
                                retorno.append(dibujarBrodeFila(posFila, celda, posColumna, fila));
                                //System.out.print(retorno);
                            } else {
                                retorno.append(dibujarRellenoFila(posColumna, celda, renglon, fila));
                                //System.out.print(retorno);
                            }

                        }
                        //System.out.println();
                        retorno.append(saltoLinea);
                        //System.out.print(retorno);
                    }
                    if (posFila == (matriz.length - 1)) {
                        retorno.append(dibujarBordeInferiorTablero(fila));
                        //System.out.print(retorno);
                    }
                }

            } catch (Exception e) {
                throw e;
            }
            return retorno.toString();
        }

        private String escribirNumeroColumna() {
            String retorno = "     ";
            for (int i = 0; i < matriz.length; i++) {
                retorno += (i + 1 + "   ");
            }
            return retorno;
        }

        private String escribirLetraFila(int pPosFila) {
            String retorno = "";
            switch (pPosFila) {
                case 0:
                    retorno = " A ";
                    break;
                case 1:
                    retorno = " B ";
                    break;
                case 2:
                    retorno = " C ";
                    break;
                case 3:
                    retorno = " D ";
                    break;
                case 4:
                    retorno = " E ";
                    break;
                case 5:
                    retorno = " F ";
                    break;
                case 6:
                    retorno = " G ";
                    break;
                case 7:
                    retorno = " H ";
                    break;
                default:
                    break;
            }
            return retorno;
        }

        private String dibujarBrodeFila(int pPosFila, Celda pCelda, int pPosColumna, Celda[] pFila) {
            String retorno = "";
            try {
                //Si la fila es la primera 
                if (pPosFila == 0) {
                    //Si la celda no tiene datos
                    if (pCelda == null) {
                        //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                        retorno = (dibujarBordeTop(pPosColumna, pFila));
                        //System.out.print(retorno);

                        //Si la columna no es la primera
                        if (pPosColumna > 0) {

                            //Si la celda izquierda tiene datos
                            if (pFila[pPosColumna - 1] != null) {

                                //Si la celda izquierda es un ladrillo
                                if (pFila[pPosColumna - 1].isEsLabrillo()) {

                                    //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                    retorno = (dibujarBordeTopAnterior(pPosColumna, pFila));
                                    //System.out.print(retorno);
                                }
                            }
                        }
                    } else {
                        //Si la celda es un ladrillo
                        if (pCelda.isEsLabrillo()) {
                            //Dibujo el borde usado con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarBordeTopUsado(pPosColumna, pFila));
                            //System.out.print(retorno);

                        } else {
                            //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarBordeTop(pPosColumna, pFila));
                            //System.out.print(retorno);

                            //Si la columna no es la primera
                            if (pPosColumna > 0) {

                                //Si la celda izquierda tiene datos
                                if (pFila[pPosColumna - 1] != null) {

                                    //Si la celda izquierda es un ladrillo
                                    if (pFila[pPosColumna - 1].isEsLabrillo()) {

                                        //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                        retorno = (dibujarBordeTopAnterior(pPosColumna, pFila));
                                        //System.out.print(retorno);
                                    }
                                }
                            }
                        }
                    }
                } else {
                    //Si la fila no es la primera
                    //Si la celda no tiene datos
                    if (pCelda == null) {

                        //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                        retorno = (dibujarBordeTop(pPosColumna, pFila));
                        //System.out.print(retorno);

                        //Si la celda de arriba no tiene datos
                        if (this.matriz[pPosFila - 1][pPosColumna] == null) {
                            //Si no es la primera columna 
                            if (pPosColumna > 0) {
                                //Si la celda izquierda no tiene datos
                                if (pFila[pPosColumna - 1] == null) {
                                    //Si la celda de arriba en diagonal izquierda tiene datos
                                    if (this.matriz[pPosFila - 1][pPosColumna - 1] != null) {
                                        //Si la celda de arriba en diagonal izquierda es un ladrillo
                                        if (this.matriz[pPosFila - 1][pPosColumna - 1].isEsLabrillo()) {
                                            //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                            retorno = (dibujarBordeTopAnterior(pPosColumna, pFila));
                                            //System.out.print(retorno);
                                        }
                                    }
                                } else {
                                    //Si la celda izquierda es un ladrillo
                                    if (pFila[pPosColumna - 1].isEsLabrillo()) {

                                        //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                        retorno = (dibujarBordeTopAnterior(pPosColumna, pFila));
                                        //System.out.print(retorno);
                                        //System.out.print(retorno + "" + pPosFila + "" + pPosColumna+ "|" );
                                    }
                                }
                            }
                        } else {
                            //Si la celda es null
                            //Si la celda de arriba tiene datos

                            //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarBordeTopAnterior(pPosColumna, pFila));
                            //System.out.print(retorno);

                            //Si la celda de arriba es un ladirllo
                            if (this.matriz[pPosFila - 1][pPosColumna].isEsLabrillo()) {
                                //Dibujo el borde usado con fin o no, dependiendo si es el borde final o no.
                                retorno = (dibujarBordeTopUsado(pPosColumna, pFila));
                                //System.out.print(retorno);
                            } else {
                                //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                                retorno = (dibujarBordeTop(pPosColumna, pFila));
                                //System.out.print(retorno); 
                                //Si no es la primera columna 
                                if (pPosColumna > 0) {
                                    //Si la celda izquierda tiene datos
                                    if (pFila[pPosColumna - 1] != null) {
                                        //Si la celda izquierda es un ladrillo
                                        if (pFila[pPosColumna - 1].isEsLabrillo()) {
                                            //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                            retorno = (dibujarBordeTopAnterior(pPosColumna, pFila));
                                            //System.out.print(retorno);
                                        }
                                    }
                                }
                            }
                        }
                    } else {
                        //Si la celda es un ladrillo
                        if (pCelda.isEsLabrillo()) {

                            //Dibujo el borde usado con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarBordeTopUsado(pPosColumna, pFila));
                            //System.out.print(retorno);

                            //Si la celda de arriba tiene datos
                            if (this.matriz[pPosFila - 1][pPosColumna] != null) {

                                //Si la celda y la anterior estan en el mismo nivel
                                if (pCelda.getNivel() == this.matriz[pPosFila - 1][pPosColumna].getNivel()) {

                                    //Si la celda es parte de un ladrillo
                                    if (pCelda.isLinderoTOP()) {
                                        //Dibujo el borde usado con fin o no, dependiendo si es el borde final o no.
                                        retorno = (dibujarBordeTopLindero(pPosColumna, pFila));
                                        //System.out.print(retorno);
                                    }
                                }
                            }
                        } else {
                            //Si la celda no es un ladrillo

                            //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarBordeTop(pPosColumna, pFila));
                            //System.out.print(retorno);

                            //Si la celda de arriba tiene datos
                            if (this.matriz[pPosFila - 1][pPosColumna] != null) {
                                //Entonces dibujo un borde ****

                                if (this.matriz[pPosFila - 1][pPosColumna].isEsLabrillo()) {

                                    //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                    retorno = (dibujarBordeTopUsado(pPosColumna, pFila));
                                    //System.out.print(retorno);
                                } else {

                                    //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                                    retorno = (dibujarBordeTop(pPosColumna, pFila));
                                    //System.out.print(retorno);
                                }
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                throw ex;
            }
            return retorno;
        }

        private String dibujarBordeTop(int pPosColumna, Celda[] pFila) {
            String retorno = "";

            if (pPosColumna == (pFila.length - 1)) {
                //System.out.print(bordeTOPFIN);
                retorno = bordeTOPFIN;
            } else {
                //System.out.print(bordeTOP);
                retorno = bordeTOP;
            }
            return retorno;
        }

        private String dibujarBordeTopUsado(int pPosColumna, Celda[] pFila) {
            String retorno = "";

            if (pPosColumna == (pFila.length - 1)) {
                //System.out.print(bordeTOPUsadoFIN);
                retorno = bordeTOPUsadoFIN;
            } else {
                //System.out.print(bordeTOPUsado);
                retorno = bordeTOPUsado;
            }
            return retorno;
        }

        private String dibujarBordeTopAnterior(int pPosColumna, Celda[] pFila) {
            String retorno = "";

            if (pPosColumna == (pFila.length - 1)) {
                //System.out.print(bordeTOPAnteriorFIN);
                retorno = bordeTOPAnteriorFIN;
            } else {
                //System.out.print(bordeTOPAnterior);
                retorno = bordeTOPAnterior;
            }
            return retorno;
        }

        private String dibujarBordeTopLindero(int pPosColumna, Celda[] pFila) {
            String retorno = "";

            if (pPosColumna == (pFila.length - 1)) {
                //System.out.print(bordeTOPLinderoFIN);
                retorno = bordeTOPLinderoFIN;
            } else {
                //System.out.print(bordeTOPLindero);
                retorno = bordeTOPLindero;
            }
            return retorno;
        }

        private String dibujarRellenoFila(int pPosColumna, Celda pCelda, int pRenglon, Celda[] pFila) {
            String retorno = "";
            try {
                //Si la columna es la primera
                if (pPosColumna == 0) {

                    //Si la celda no tiene datos
                    if (pCelda == null) {

                        //Dibujo el relleno vacio con fin o no, dependiendo si es el borde final o no.
                        retorno = (dibujarBordeLeft(pPosColumna, pFila));
                        //System.out.print(retorno);
                    } else {

                        //Si la celda es un ladrillo
                        if (pCelda.isEsLabrillo()) {

                            //Dibujo el relleno de ladrillo con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarRellenoLadrillo(pRenglon, pPosColumna, pCelda, pFila));
                            //System.out.print(retorno);
                        } else {

                            //Dibujo el relleno de ficha con fin o no, dependiendo si es el borde final o no.
                            retorno = (dibujarRellenoFicha(pRenglon, pPosColumna, pFila.length, null, pCelda));
                            //System.out.print(retorno);
                        }
                    }
                } else {
                    //Si no es la primer celda
                    //Si la celda no tiene datos
                    if (pCelda == null) {
                        //Dibujo el relleno vacio con fin o no, dependiendo si es el borde final o no.
                        retorno = (dibujarBordeLeft(pPosColumna, pFila));
                        //System.out.print(retorno);
                        //Si la celda izquierda tiene datos
                        if (pFila[pPosColumna - 1] != null) {
                            if (pFila[pPosColumna - 1].isEsLabrillo()) {
                                //Dibujo el relleno vacio con fin o no, dependiendo si es el borde final o no.
                                retorno = (dibujarRellenoLadrillo(pRenglon, pPosColumna, pCelda, pFila));
                                //System.out.print(retorno);
                            }
                        }
                    } else {
                        //Si la celda tiene datos.
                        //Si la celda actual es un ladrillo
                        if (pCelda.isEsLabrillo()) {

                            retorno = (dibujarRellenoLadrillo(pRenglon, pPosColumna, pCelda, pFila));
                            //Si la celda izquierda tiene datos.
                            if (pFila[pPosColumna - 1] != null) {

                                //Si la celda actual y la anterior pertenecen al mismo nivel
                                if (pCelda.getNivel() == pFila[pPosColumna - 1].getNivel()) {
                                    if (pCelda.isLinderoLEFT()) {
                                        retorno = (dibujarRellenoLindero(pRenglon, pPosColumna, pFila.length, pCelda));
                                    }
                                }
                            }
                        } else {
                            retorno = (dibujarRellenoFicha(pRenglon, pPosColumna, pFila.length, pFila[pPosColumna - 1], pCelda));
                        }
                    }
                }
            } catch (Exception ex) {
                throw ex;
            }
            return retorno;
        }

        private String dibujarRellenoLadrillo(int pRenglon, int pPosColumna, Celda pCelda, Celda[] pFila) {
            String retorno = String.format(bordeLEFUsado, " ", " ", " ");
            try {
                //Si la celda tiene datos
                if (pCelda != null) {
                    //Si estamos en el renglo dos o tres
                    if (pRenglon == 1 || pRenglon == 3) {

                        if (pPosColumna == (pFila.length - 1)) {
                            //System.out.print(String.format(bordeLEFUsadoFIN, " ", pCelda.getNivel(), " "));
                            retorno = String.format(bordeLEFUsadoFIN, " ", pCelda.getNivel(), " ");
                        } else {
                            //System.out.print(String.format(bordeLEFUsado, " ", pCelda.getNivel(), " "));
                            retorno = String.format(bordeLEFUsado, " ", pCelda.getNivel(), " ");
                        }
                    }
                    if (pRenglon == 2) {
                        if (pPosColumna == (pFila.length - 1)) {
                            if (pCelda.getFicha() == null) {
                                retorno = String.format(bordeLEFUsadoFIN, pCelda.getNivel(), pCelda.getNivel(), pCelda.getNivel());
                            } else {
                                retorno = String.format(bordeLEFUsadoFIN, pCelda.getNivel(), pCelda.getFicha(), pCelda.getNivel());
                            }
                        } else {
                            if (pCelda.getFicha() == null) {
                                retorno = String.format(bordeLEFUsado, pCelda.getNivel(), pCelda.getNivel(), pCelda.getNivel());
                            } else {
                                retorno = String.format(bordeLEFUsado, pCelda.getNivel(), pCelda.getFicha(), pCelda.getNivel());
                            }
                        }
                    }
                } else {
                    if (pPosColumna > 0 && pFila[pPosColumna - 1] != null) {
                        retorno = dibujarBordeLeftAnterior(pPosColumna, pFila);
                    }
//                else {
//                    if (pPosColumna == (pFila.length - 1)) {
//                        retorno = String.format(bordeLEFUsadoFIN, " ", " ", " ");
//                    }
//                }
                }

            } catch (Exception ex) {
                throw ex;
            }
            return retorno;
        }

        private String dibujarRellenoFicha(int pRenglon, int pPosColumna, int pFilaLength, Celda pCeldaAnterior, Celda pCelda) {
            String retorno = "";
            try {
                if (pRenglon == 1 || pRenglon == 3) {

                    if (pPosColumna == (pFilaLength - 1)) {
                        retorno = (String.format(bordeLEFFichaFIN, " ", (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", " "));
                        if (pCeldaAnterior != null) {
                            if (pCeldaAnterior.isEsLabrillo()) {
                                retorno = (String.format(bordeLEFFichaAnteriorFIN, " ", (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", " "));
                            }
                        }
                    } else {
                        if (pCeldaAnterior == null) {
                            retorno = (String.format(bordeLEFFicha, " ", (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", " "));
                        } else {
                            if (pCeldaAnterior.isEsLabrillo()) {
                                retorno = (String.format(bordeLEFFichaAnterior, " ", (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", " "));
                            } else {
                                retorno = (String.format(bordeLEFFicha, " ", (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", " "));
                            }
                        }
                    }
                }
                if (pRenglon == 2) {
                    if (pPosColumna == (pFilaLength - 1)) {

                        if (pCeldaAnterior == null) {
                            retorno = (String.format(bordeLEFFichaFIN, (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", pCelda.getFicha(), (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " "));
                        } else {
                            if (pCeldaAnterior.isEsLabrillo()) {
                                retorno = (String.format(bordeLEFFichaAnteriorFIN, (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", pCelda.getFicha(), (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " "));
                            } else {
                                retorno = (String.format(bordeLEFFichaFIN, (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", pCelda.getFicha(), (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " "));
                            }
                        }
                    } else {
                        if (pCeldaAnterior == null) {
                            retorno = (String.format(bordeLEFFicha, (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", pCelda.getFicha(), (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " "));
                        } else {
                            if (pCeldaAnterior.isEsLabrillo()) {
                                retorno = (String.format(bordeLEFFichaAnterior, (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", pCelda.getFicha(), (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " "));
                            } else {
                                retorno = (String.format(bordeLEFFicha, (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " ", pCelda.getFicha(), (pCelda.isEsLabrillo()) ? pCelda.getNivel() : " "));
                            }
                        }
                    }
                }
            } catch (Exception ex) {
                throw ex;
            }
            return retorno;
        }

        private String dibujarRellenoLindero(int pRenglon, int pPosColumna, int pFilaLength, Celda pCelda) {
            String retorno = "";
            try {
                if (pRenglon == 1 || pRenglon == 3) {

                    if (pPosColumna == (pFilaLength - 1)) {
                        //System.out.print(String.format(bordeLEFLinderoFIN, " ", pCelda.getNivel(), " "));
                        retorno = String.format(bordeLEFLinderoFIN, " ", pCelda.getNivel(), " ");
                    } else {
                        //System.out.print(String.format(bordeLEFLindero, " ", pCelda.getNivel(), " "));
                        retorno = String.format(bordeLEFLindero, " ", pCelda.getNivel(), " ");
                    }
                }
                if (pRenglon == 2) {
                    if (pPosColumna == (pFilaLength - 1)) {
                        if (pCelda.getFicha() == null) {
                            retorno = String.format(bordeLEFLinderoFIN, pCelda.getNivel(), pCelda.getNivel(), pCelda.getNivel());
                        } else {
                            retorno = String.format(bordeLEFLinderoFIN, pCelda.getNivel(), pCelda.getFicha(), pCelda.getNivel());
                        }
                    } else {
                        if (pCelda.getFicha() == null) {
                            retorno = String.format(bordeLEFLindero, pCelda.getNivel(), pCelda.getNivel(), pCelda.getNivel());
                        } else {
                            retorno = String.format(bordeLEFLindero, pCelda.getNivel(), pCelda.getFicha(), pCelda.getNivel());
                        }
                    }
                }

            } catch (Exception ex) {
                throw ex;
            }
            return retorno;
        }

        private String dibujarBordeLeft(int pPosColumna, Celda[] pFila) {
            String retorno = "";

            //Este bloque controla el caso de bore 
            //cuando la columna es la ultima
            if (pPosColumna == (pFila.length - 1)) {
                //System.out.print(bordeLEFFIN);
                retorno = bordeLEFFIN;
            } else {
                //System.out.print(bordeLEF);
                retorno = bordeLEF;
            }
            return retorno;
        }

        private String dibujarBordeLeftAnterior(int pPosColumna, Celda[] pFila) {
            String retorno = "";

            //Este bloque controla el caso de bore 
            //cuando la columna es la ultima
            if (pPosColumna == (pFila.length - 1)) {
                //System.out.print(bordeLEFFIN);
                retorno = bordeLEFAnteriorFIN;
            } else {
                //System.out.print(bordeLEF);
                retorno = bordeLEFAnterior;
            }
            return retorno;
        }

        private String dibujarBordeInferiorTablero(Celda[] pFila) {
            StringBuilder retorno = new StringBuilder(margen);
            try {
                //System.out.print(margen);
                //Recorro cada celda para ver si tengo que dibujarla con contenido
                for (int posColumna = 0; posColumna < pFila.length; posColumna++) {
                    Celda celda = pFila[posColumna];
                    //Si la celda no tiene datos
                    if (celda == null) {
                        //Si no es la primera celda
                        if (posColumna > 0) {
                            //Si la celda izquierda no tiene datos
                            if (pFila[posColumna - 1] == null) {
                                //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                                retorno.append(dibujarBordeTop(posColumna, pFila));
                            } else {
                                //Si la celda izquierda es un ladrillo
                                if (pFila[posColumna - 1].isEsLabrillo()) {
                                    //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                                    retorno.append(dibujarBordeTopAnterior(posColumna, pFila));
                                    //System.out.print(retorno);
                                } else {
                                    //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                                    retorno.append(dibujarBordeTop(posColumna, pFila));
                                    //System.out.print(retorno);
                                }
                            }
                        } else {
                            //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                            retorno.append(dibujarBordeTop(posColumna, pFila));
                            //System.out.print(bordeTOP);
                        }
                    } else {
                        if (celda.isEsLabrillo()) {
                            //Dibujo el borde usado anterior con fin o no, dependiendo si es el borde final o no.
                            retorno.append(dibujarBordeTopUsado(posColumna, pFila));
                            //System.out.print(retorno);
                        } else {
                            //Dibujo el borde vacio con fin o no, dependiendo si es el borde final o no.
                            retorno.append(dibujarBordeTop(posColumna, pFila));
                            //System.out.print(retorno);
                        }
                    }
                }
                retorno.append(saltoLinea);

            } catch (Exception ex) {
                throw ex;
            }
            return retorno.toString();
        }
    }
}
